Amiga Format CD 41/Amiga Format CD41 (1999-06)(Future Publishing)(GB)[!][issue 1999-07].iso/-seriously_amiga-/programming/other/flexcat/lib/c_c_v20.sd

Text File | 1999-04-19 | 5KB | 207 lines

##stringtype C
##shortstrings
/****************************************************************
   This file was created automatically by `%fv'
   from "%f0".

   Do NOT edit by hand!
****************************************************************/

#include <string.h>

#include <exec/memory.h>
#include <libraries/iffparse.h>


#if defined(__SASC)  ||  defined(_DCC)
#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/utility.h>
#include <proto/iffparse.h>
#include <proto/locale.h>
#elif defined(__GNUC__)
#include <inline/locale.h>
#include <inline/iffparse.h>
#include <inline/dos.h>
#include <inline/exec.h>
#include <inline/utility.h>
#else
#include <clib/iffparse_protos.h>
#include <clib/locale_protos.h>
#include <clib/dos_protos.h>
#include <clib/exec_protos.h>
#include <clib/utility_protos.h>
#endif





static LONG %b_Version = %v;
static const STRPTR %b_BuiltInLanguage = (STRPTR) %l;

struct FC_Type
{   LONG    ID;
    STRPTR  Str;
};

const struct FC_Type _%i = { %d, %s };

static struct Catalog *%b_Catalog = NULL;
static struct FC_Type *%b_OwnCatalog = NULL;
static LONG %b_OwnStrings;
static LONG %b_OwnBytes;

void Open%bCatalog(struct Locale *loc, STRPTR language)
{ LONG tag, tagarg;
  extern struct Library *LocaleBase;
  extern struct Library *IFFParseBase;
  extern void Close%bCatalog(void);

  Close%bCatalog();  /*  Not needed if the programmer pairs Open-()
             and CloseCatalog() right, but does no harm. */
  if (language == NULL)
  { tag = TAG_IGNORE;
  }
  else
  { tag = OC_Language;
    tagarg = (LONG) language;
  }
  if (LocaleBase != NULL  &&  %b_Catalog == NULL)
  { %b_Catalog = OpenCatalog(loc, (STRPTR) "%b.catalog",
                 OC_BuiltInLanguage, %b_BuiltInLanguage,
                 tag, tagarg,
                 OC_Version, %b_Version,
                 TAG_DONE);
  }
  if (LocaleBase == NULL  &&  IFFParseBase != NULL  &&  language != NULL  &&
      Stricmp(language, %b_BuiltInLanguage) != 0)
  { struct IFFHandle *iffhandle;
    char path[128]; /*    Enough to hold 4 path items (dos.library 3.0)  */

    if ((iffhandle = AllocIFF())  !=  NULL)
    { /*  Trying to open the catalog  */
      strcpy(path, "Catalogs");
      AddPart((STRPTR) path, language, sizeof(path));
      AddPart((STRPTR) path, (STRPTR) "%b.catalog", sizeof(path));
      if ((iffhandle->iff_Stream = Open((STRPTR) path, MODE_OLDFILE))
                 ==  NULL)
      { strcpy(path, "Locale:Catalogs");
    AddPart((STRPTR) path, language, sizeof(path));
    AddPart((STRPTR) path, (STRPTR) "%b.catalog", sizeof(path));
    iffhandle->iff_Stream = Open((STRPTR) path, MODE_OLDFILE);
      }

      if (iffhandle->iff_Stream)
      { InitIFFasDOS(iffhandle);
    if (!OpenIFF(iffhandle, IFFF_READ))
    { if (!PropChunk(iffhandle, MAKE_ID('C','T','L','G'),
             MAKE_ID('S','T','R','S')))
      { struct StoredProperty *sp;
        int error;

        for (;;)
        { if ((error = ParseIFF(iffhandle, IFFPARSE_STEP))
             ==  IFFERR_EOC)
          { continue;
          }
          if (error != 0)
          { break;
          }

          if (sp = FindProp(iffhandle, MAKE_ID('C','T','L','G'),
                MAKE_ID('S','T','R','S')))
          { LONG *ptr;
        LONG BytesToScan, StrLength;

        /*  First scan: Check the number of strings        */
        /*  Note that this assumes that the strings are padded    */
        /*  to a longword boundary!                */
        %b_OwnBytes = 0;
        %b_OwnStrings = 0;
        BytesToScan = sp->sp_Size;
        ptr = sp->sp_Data;
        while (BytesToScan > 0)
        { ++%b_OwnStrings;
          ++ptr;              /*  Skip ID        */
          StrLength = *ptr+1;          /*  NUL-Byte!        */
          %b_OwnBytes += StrLength;
          ptr += 1+(StrLength+3)/4;   /*  Skip Length and String*/
          BytesToScan -= 8+((StrLength+3)/4)*4;
        }

        /*  Marginal check: BytesToScan has to be 0!        */
        if (BytesToScan == 0)
        { char *cptr;
          LONG i;

          if (%b_OwnCatalog = (struct FC_Type *)
              AllocMem(%b_OwnStrings*sizeof(struct FC_Type)+%b_OwnBytes,
                   MEMF_ANY))
          { /*    Second scan: Copy the strings and their ID's    */
            cptr = (char *) &%b_OwnCatalog[%b_OwnStrings];
            BytesToScan = sp->sp_Size;
            ptr = sp->sp_Data;
            i = 0;
            while (BytesToScan > 0)
            { %b_OwnCatalog[i].ID = *(ptr++);
              %b_OwnCatalog[i].Str = (STRPTR) cptr;
              StrLength = *ptr+1;     /*  NUL-Byte!        */
              ptr++;
              strncpy(cptr, (char *) ptr, StrLength);
                    /*  Not more, not less bytes!    */
              cptr+=StrLength;
              ptr += (StrLength+3)/4;
              BytesToScan -= 8+((StrLength+3)/4)*4;
              ++i;
            }
            break;
          }
        }
          }
        }
      }
      CloseIFF(iffhandle);
    }
    Close(iffhandle->iff_Stream);
      }

      FreeIFF(iffhandle);
    }
  }
}


void Close%bCatalog(void)
{ if (LocaleBase != NULL)
  { CloseCatalog(%b_Catalog);
  }
  %b_Catalog = NULL;
  if (%b_OwnCatalog != NULL)
  { FreeMem(%b_OwnCatalog,
        %b_OwnStrings*sizeof(struct FC_Type)+%b_OwnBytes);
    %b_OwnCatalog = NULL;
  }
}


STRPTR Get%bString(APTR fcstr)
{ STRPTR defaultstr = NULL;
  LONG strnum, i;

  strnum = ((struct FC_Type *) fcstr)->ID;
  defaultstr = ((struct FC_Type *) fcstr)->Str;

  if (%b_Catalog == NULL)
  { if (%b_OwnCatalog != NULL)
    { for (i = 0;  i < %b_OwnStrings;  i++)
       { if (%b_OwnCatalog[i].ID == strnum)
     { return(%b_OwnCatalog[i].Str);
     }
       }
    }
    return(defaultstr);
  }
  return(GetCatalogStr(%b_Catalog, strnum, defaultstr));
}